<html>
    <head>
        <title>note</title>
    </head>
    <body>
        <pre>
        1.线程的状态：
        new---没有start之前；
        runnable---调用start，代表它**具备执行**的资格
        由于存在running状态，runnable只能意味终止或进入running状态；
            running---直接进入terminated，进入blocked（sleep、wait等)
            进入runnable（cpu调度、yield方法）；
            blocked状态---直接进入terminated，进入runnable（完成休眠、被notify、获得锁、被打断）</br>
            terminated状态---正常结束、运行出错、JVM Crash
        2.阅读thread源码：
            private static native void registerNatives();
            static {
            registerNatives();
            }
            一个java程序想要调用一个本地方法，需要执行两个步骤：
            第一，通过System.loadLibrary()将本地方法实现的动态文件加载进内存；
            第二，当程序需要调用本地方法时，虚拟机在加载的动态文件中定位并链接该本地方法。
            registerNatives就是取代第二步，让程序主动将本地方法链接到调用方，当java程序需要
            调用本地方法时就可以直接调用。

            public static void sleep(long millis, int nanos)
            对时间做了近似处理？？？

            重写clone方法，不能clone

            This method is not invoked for the main method thread or "system"
            group threads created/set up by the VM. Any new functionality added
            to this method in the future may have to also be added to the VM.

            public synchronized void start() {

            if (threadStatus != 0)
                throw new IllegalThreadStateException();

                group.add(this);

            boolean started = false;
            try {
                start0();
                started = true;
            } finally {
                try {
                    if (!started) {
                        group.threadStartFailed(this);
                    }
                } catch (Throwable ignore) {

                }
            }
        }
        </pre>
        <pre>
        3.Thread构造函数
            语义上来讲，Thread负责线程本身相关的职责（相关context环境的设置、相关流程的设置和管理），
            Runnable则负责逻辑执行单元。
            Thread相关实现中只是为留了一个给用户实现的钩子而已。
            构造Thread时指定StackSize，但是这个参数的平台依赖性相当高
        </pre>
        <pre>
        3.TimeUnit
            JDK1.5引入的一个枚举,枚举的深入了解?
        4.线程yeild和sleep的区别（yeild属于一种启发式的方法）
        5.设置线程优先级：
            一般不会对线程设定优先级别，更不会让某些业务严重依赖线程的优先级，线程的优先级
            与具体硬件底层相关，有些操作系统会忽略程序中设置的优先级
        6.interrupt方法
            设置线程的interrupt flag标志，抛出InterruptedException，interrupt后处于什么状态
            Thread.interrupted是一个静态方法会直接擦除interrupt标识
            isInterrupted和Thread.interrupted都是调用同一个本地方法，但是传的参数不同，决定
            是不是在检测完成之后清除flag
        7.线程join
             调用某个线程对象的join,会使其当前context的线程wait？？？？
        8.如何正常的关闭线程（stop废弃不推荐使用）
            捕获中断信号关闭
            使用volatile（interrupt信号很有可能被擦除或者逻辑单元不会调用任何可中断方法）
        9.异常退出，进程假死
        </pre>
        <pre>
        10.Thread里State的几种不同区别？？？
        11.Jconsole里MBean的含义？？？？
        12.使用synchronized需要注意的事项：
            与monitor关联的对象不能为空
            sychronized的作用域不能太大
            多个锁的交叉
            When a thread invokes a sychronized method,it automatically acquires
        the intrinsic lock for that method's object and releases it when the method
        returns.The lock release occurs even if the return was caused by an uncaught
        exception.
         13.程序死锁及诊断
            分析常见的容器结构的源码实现，给出时序图来思考为什么会存在线程安全！
         14.wait、notify
            使用那个对象加的锁，必须执行那个对象的monitor
         15.wait set
            虚拟机规范存在一个wait set的概念，但是怎样的实现并没有规定。
         16.sychronized关键字缺陷
            排它式,无法控制阻塞时长，阻塞不可被中断，在sychronized代码块中可以捕获
            InterruptedException,但是不会释放锁，但是线程会死掉（可能）
         17.线程组ThreadGroup源码阅读
            @FunctionalInterface，a functional interface has exactly one abstract method.
            源码较简洁、好懂，后续有需要再详细阅读！
         18.UncaughtExceptionHandler
            线程再执行单元是无法抛出checked异常，当线程运行过程出现异常时，jvm会调用
            dispatchUncaughtException方法，这个方法会将对应的线程实例以及异常信息接口传递给
            回调接口
         19.注入钩子线程
            Hook只有再收到退出信号时会被执行，如果再kill的时候使用了参数-9，那么Hook
            线程不会得到执行
            Hook线程中也可以执行一些资源释放的工作
         20.线程池原理以及自定义线程池
            自JDK1.5起，utils包提供了ExcutorService线程池的实现，主要目的是为了高效利用
            线程资源。
            任务队列：用于缓存提交的任务
            线程数量管理功能：根据提交和处理情况动态改变线程数量
            任务拒绝策略：
            线程工厂：用于个性化定制线程
            QueueSize：
            Keepedalive时间：
         21.类加载
            jvm规范规定了，每个类或接口被java程序首次主动使用时才会对其进行初始化
            6种主动使用的场景：
                new关键字
                访问类的静态变量
                访问类的静态方法
                对某个类进行反射操作
                初始化子类会导致父类的初始化
                启动类
            除了这6种情况，其余的都是被动引用，不会导致类的加载和初始化
                构造类的数组不会导致该类的初始化
                引用类的静态常量不会导致类的初始化

         22.类加载
            虚拟机规范中指出了类的加载是通过一个全限定名来获取二进制流，但并没有限定
            必须通过某种方式去获得，常见的几种形式：
                class文件
                运行时动态生成，ASM、java.lang.Proxy
                网络获取，Applet小程序以及RMI动态发布
                读取zip文件
                将类的二进制数据存储在数据库的BLOB字段类型中
                运行时生成class文件,并且动态加载，比如使用Thrift、AVRO等都是可以在运行时
                将某个Schema文件生成对应的若干个class文件，然后再进行加载
         23.类的连接阶段
            验证
            准备，为对象的类变量，也就是静态变量，分配内存并设置初值
            解析，
         24.类的初始化阶段
            &lt;cinit&gt;在编译阶段生成，包含了所有类变量的赋值动作和静态语句块的执行代码
            根据在源文件中出现的顺序，能够保证顺序性
            并不是一定会生成这个方法，jvm保证了此方法在多线程环境下同步语义
         25.类加载器
            对于任意一个class，都需要加载它的类加载器和这个类本身确立其在JVM中的
            唯一性。
            父委托机制,
            Bootstrap ClassLoader,最顶层,由c++编写，主要负责虚拟机核心类库的加载
            -Xbootclasspath来指定
            ExtClassLoader,主要用于加载JAVA_HOME下的jre/lib/ext子目录的类库，由纯java
            语言实现，由java.ext.dirs获得
            ApplicationClassLoader，负责加载classpath下的类库资源，加载路径一般通过-classpath
            指定，也可以通过java.class.path进行获取
            所有的自定义类加载器都是ClassLoader的直接子类或间接子类
            loadClass并不会导致类的主动初始化，它只是执行了加载过程中的加载阶段而已
            绕过系统类加载器的两种方法，直接将ExtClassLoader作为自己的类装载器，直接将父类加载器置空
         26.类加载器命名空间
            同一个class实例在同一个类加载器命名空间是唯一的
         27.运行时包
            由类加载器的命名空间和类的全限定名共同组成的
            如果某个类c被类加载器cl加载，cl就被称为c的初始类加载器。JVM为每一个类加载
           器维护了一个列表，该列表中记录了将该类加载器作为初始类加载器的所有class，根据jvm
            规范，即使没有亲自加载该类，也都会被标注为该类的初始类加载器。
            Apache Drools
         28.线程上下文类加载器
            与类加载器双亲委托机制分不开，JDK提供了很多SPI，如JDBC、JCE、JNDI、
            JAXP和JBI等，JDK只规定了这些接口之间的逻辑关系，但不提供逻辑实现，具体
            的实现由第三方厂商实现。
            而java.lang.sql中的所有接口都由JDK提供，由根加载器加载,而第三方厂商
            提供的类库驱动则是由系统类加载。

            打破了父委托机制，根加载器反而需要委托子加载器加载厂商的SPI实现（线程上下文类加载器）
         29.volatile关键字
            只能修饰类变量和实例变量，对于方法参数、局部变量以及实例常量，类常量不能进行修饰
         30.cpu缓存一致性问题
            通过总线加锁
            通过一致性缓存协议
            第一种常见于早期的cpu，一种悲观的实现方式
            第二种最为出名的是Intel的MESI协议
         31.并发的三大特性
            原子性
            可见性
            顺序性，happend before
         32.sychronized与volatile的区别
            使用上的区别
            对原子性的保证
            对可见性的保证，sychronized借助jvm的monitor enter和monitor exit
         对通过排它的方式使得同步代码串行化，在monitor exit时所有共享资源都将会
         被刷新到主内存中。volatile使用机器指令（偏硬件）"lock;"的方式迫使其他
         线程工作内存中的数据失效对顺序性的保证
            对有序性的保证
         33.单例模式的几种实现
            高性能、单实例、懒加载
         34.监控任务的生命周期
            给线程的执行增加钩子，利用观察者模式
         35.Single Thread Execution
            classpath的设置：系统环境变量设置、启动JVM时设置，推荐第二种方式
            如果没有进行设置，默认为"."
            在IDE中运行，IDE自动传入的参数是当前工程的bin目录和引入的jar包
            不要把任何java核心库添加到classpath中
         36.读写锁分离
            对共享资源读写进行更细致的管理，将颗粒度细分到读、写操作
         37.不可变对象的设计
            无论是sychronized关键字还是显式锁Lock，都会牺牲系统的性能，不可变对象
            的设计理念越来越收到青睐，Actor模型以及函数式编程语言Clojure等都是依赖于
            不可变对象的设计达到lock free的。
            java类库有大量不可变对象范例，如String，里面所有方法都没有加同步，每次都会返回一个
            新的对象。有些非线程安全对象被不可变机制加以处理后，照样也可以具备不可变性
         38.Future设计模式
            返回一个能获取最终结果的对象
         39.Guarded Suspension设计模式
            确保挂起
         40.线程上下文设计模式
            ThreadLocal的使用场景及注意事项：
            对象跨层传递、线程间数据隔离、存储线程事务信息
            ThreadLocal源码阅读：
         41.Balking设计模式
            犹豫
         42.Latch设计模式
            CountDownLatch的设计实现，超时功能的改进
         43.Thread-Per-Message设计模式
         44.Two Phase Termination
            进行线程两阶段终结需考虑：
            第二阶段的终止保证安全性
            要百分百地确保线程结束
            对资源的释放时间要控制在一个可控的范围之内
            类似File、Socket等重量级资源，进行释放时不能百分百的保证成功
            PhantomReference，借助它可以很好的获取那个对象即将被垃圾回收器清除，
        在清除之前还可以尝试依次资源回收
            强引用：只要可达，gc都不会释放
            GC的类型，不同引用在gc时的不同用处？？？
        45.WorkThread模式
            与生产者消费者模式的区别
        46.ActiveObjects模式
            接收异步消息的主动对象
            
        47.EventBus设计模式
            消息中间件，主要是用于解决进程之间消息异步处理的解决方案

        48.EventDriven设计模式

        第二阶段的ActiveObjects和EventBus设计模式和EventDriven设计模式留待后续
        </pre>
        <pre>
        第三阶段，java并发包，源码解读
        1.ThreadLocal源码阅读
            jdk1.2 Doug Lea
            没有继承（除Object），没有实现其他接口
            The ThreadLocal objects act as keys,searched via threadLocalHashCode
         
            ThreadLocalMap:is a cutomized hash map  suitable only for mataining thread local values

            ThreadMap持有一个entry数组

            ThreadLocal和Thread类的配合使用？？？？？？


            protected T initialValue() {return null;}

            public static <S> ThreadLocal<S> withInitial(Supplier<? extends S> supplier) {
               return new SuppliedThreadLocal<>(supplier);
           }
           
           SupperliedThreadLocal--继承ThreadLocal，重写initialValue，里面调用supplier.get()

           public T get()

           getMap()获取Thread.threadLocals,如果为空，则会设置，初始值为initialValue返回值，get也返回
           initialValue()的值
           如果Thread.threadLocals不为空，获取entry，如果entry为空，则会setinitialValue

           public void set()


            idea中:alt+->切换tab;ctrl+b跳到定义处


           ThreadLocal.ThreadLocalMap threadLocals=null
           ThreadLocal.ThreadLocalMap inheritableThreadLocals=null

           初始化一个线程时：
           parent=currentThread();
           if (inheritThreadLocals && parent.inheritableThreadLocals != null){

               this.inheritableThreadLocals =
               ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);

           }
           只有Thread(Runnable target, AccessControlContext acc) {
            init(null, target, "Thread-" + nextThreadNum(), 0, acc, false);
            }构造函数传入false，其余都是默认的true 
            
            static ThreadLocalMap createInheritedMap(ThreadLocalMap parentMap) {
               return new ThreadLocalMap(parentMap);
           }   
           转换为ThreadLocalMap的新建

           get方法：getMap(currentThread())，即返回t.threadLocals；
           如果map为空或根据Thread为key的值为空，则setinitialValue();
           调用initialValue获取value，如果map为空，则createMap(),否则set

           set方法：getMap(currentThread())，即返回t.threadLocals；
           如果map为空或根据Thread为key的值为空，则setinitialValue();
           调用initialValue获取value，如果map为空，则createMap(),否则set

           get和set方法中，如果当前线程的threadLocals为null，都会createMap(currentThread(),initialValue())

           void createMap(Thread t, T firstValue) {
            t.threadLocals = new ThreadLocalMap(this, firstValue);
        }
        
        一个ThreadMap持有一个field:private Entry[] table
        
        ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
         table = new Entry[INITIAL_CAPACITY];
         int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
         table[i] = new Entry(firstKey, firstValue);
         size = 1;
         setThreshold(INITIAL_CAPACITY);
     }
     根据threadLocalHashCode进行散列，然后存放在entry数组中

     各个线程持有自身的ThreadLocalMap，其中的entry为全局的ThreadLocal对象，
     多个全局的ThreadLocal都存放在一个ThreadLocalMap中，散列进行存放

     set方法：
   2.AtomicXXX源码阅读
     主要是依靠sun.misc.Unsafe包里提供的内容
     sun.misc.Unsafe主要：
      （1）Info相关。主要返回某些低级别的内存信息：addressSize(), pageSize()

      （2）Objects相关。主要提供Object和它的域操纵方法：allocateInstance(),objectFieldOffset()

      （3）Class相关。主要提供Class和它的静态域操纵方法：staticFieldOffset(),defineClass(),
      
         defineAnonymousClass(),ensureClassInitialized()

      （4）Arrays相关。数组操纵方法：arrayBaseOffset(),arrayIndexScale()

      （5）Synchronization相关。主要提供低级别同步原语（如基于CPU的CAS（Compare-And-Swap）原语）：
         monitorEnter(),tryMonitorEnter(),monitorExit(),compareAndSwapInt(),putOrderedInt()

      （6）Memory相关。直接内存访问方法（绕过JVM堆直接操纵本地内存）：allocateMemory(),copyMemory(),
         freeMemory(),getAddress(),getInt(),putInt()

         操纵对象属性、操纵数组元素、线程挂起与恢复、CAS

         public native int arrayBaseOffset(Class arrayClass);
         public native int arrayIndexScale(Class arrayClass);
      
         arrayBaseOffset,获取第一个元素的偏移地址；arrayIndexScale，获取元素的增量地址

         unsafe.getIntVolatile(array, offset)

         获取对象偏移地址对应field的值，支持volatile load语义。

         


         AtomicInteger、AtomicBoolean都是依靠一个volatile值，然后借助Unsafe里的内容，AtomicLong因为涉及CPU
      长度，额外有一些操作。  AtomicReference则是包装一个V泛型，保证value实际指向修改的一致性。

         CAS操作存在的ABA问题：AtomicStampReference，使用了一个Pair内部类将reference和版本封装了起来
         比较并交换时，需要进行版本的比对和更新。

      AtomicIntegerArray、AtomicLongArray、AtomicReferenceArrary：普通数组具备的问题？？？(其中的值也可能拷贝到线程缓冲)
      
      AtomicIntegerFieldUpdater的适用场景：不能访问私有的 源码解读

      JVM启动时通过Bootstrap ClassLoader类加载器加载rt.jar等核心jar包中的文件，int.class、String.class都是由它加载。然后，
      JVM初始化sun.misc.Lanuncher并创建Exstension ClassLoader和AppClassLoader实例

      3.AbstractQueuedSynchronizer的理解:

         AbstractQueuedSynchronizer extends AbstractOwnabesynchronizer
      
         provides a framework for implementing blocking locks and related sychronizers(semahores,events ,etc)that rely on
      first-in-first-out(FIFO)wait queues.This class is designed to be a useful basis for most kinds of sychronizers that rely on
      a single atomic int value to represent state.Subclasses must define the protected methods that change this state,and 
      which define what that state means in terms of this object being acquired or released.Given this,the other methods in
      this class carray out all queuing and blocking mechanics.Subclasses can matain other state fields，but only the atomiclly
      updated int value manipulated using methods getState setState and compareAndSetState is tracked  with respect to 
      Synchronization.
         Subclasses should be defined as non-public internal helper classes that are used to implement the sychronization 
      properties of their enclosing class.
         AbstractQueuedSychronizer does not implements any synchonization interface.Instead, it defines methods such as 
      acquireInterruptibly that can be invoked  as appropriate by concrete locks and related sychronizers to implements their
      public methods.


      ???
         this class supports either or both a default exclusive mode and a shared mode.When acquired in exclusive mode,attemped 
      acquires by  other threads cannot succeed.Shared mode acquires by multiple threads may be succeed.This class does not 
      understand;these differences except in the mechanical  sense that when a shared mode acquires succeeds,the next wating 
      thread must also determine whether it can acquires as well.
      ???

         Threads waiting in the differrent  modes share the same FIFO queue.Usually ,implementation subclasses support only one of 
      these modes,but both  can come into play for example in a ReadWriteLock.Subclasses that support only exclusives or only  shared
      modes need not define the methods supporing the used mode.
         This class defines a nested ConditionObject class that can be used as a Condition implementation by subclasses supporing exclusive
      mode for which method isHeldExclusively reports whether synchronization is exclusively help with respect to the current thread,method
      release invoked with the current getState value fully releases this object.     

      最快失败

      自旋、LockSupport、cas
      
      int state=getState()是不是原子操作？？？？

      BIO、AIO、NIO：

         BIO：java.io包，基于流模型实现，交互的方式是同步、阻塞方式
         NIO：java.nio包，java1.4引入，构建多路复用、同步非阻塞IO程序，同时提供了更接近os底层高性能的数据操作方式
         AIO：NIO的升级版本，提供了异步非阻塞的IO操作方式,基于事件和回调机制

      AbstractOwnableSynchronizer：
         
         A synchronizer that may be exclusively owned by a thread.This is class provides a basis for creating locks and 
      related sychronizers that may entail a notion of ownership.

      LockSupport:

         Basic thread blocking primitives for creating locks and other synchronization classes.
      This class associates,with each thread that uses it,a permit.A call to park will return 
      immediately if the permit is available,consuming it in the process;otherwise it block.
      A call to unpark makes the permit available,if it was not already available(Unlike with
      semaphores though,permits do not accumulate.There is at most one).   


      4.高并发工具包源码体系解读


      5.集合、高并发集合源码解读

        </pre>
    </body>
</html>